import re
from typing import List, Dict, Any, Union, Optional

# 全局注册表存储
registry: Dict[str, List[Any]] = {}
# 列表计数器，用于生成唯一编号
list_counter = 0
# 元素计数器，用于生成唯一编号
element_counter = 0

def generate_list_id() -> str:
    """生成列表的唯一ID，格式为xxx-0000"""
    global list_counter
    list_id = f"{list_counter:03d}-0000"
    list_counter += 1
    return list_id

def generate_element_id(list_id: str) -> str:
    """生成元素的唯一ID，基于列表ID"""
    global element_counter
    # 提取列表ID的前三位
    prefix = list_id.split('-')[0]
    element_id = f"{prefix}-{element_counter:04d}"
    element_counter += 1
    # 如果达到1000个元素，重置计数器（根据要求最多1000个元素）
    if element_counter >= 1000:
        element_counter = 0
    return element_id

def strp(separator: str, text: str, end_separator: str = "") -> List[str]:
    """
    增强版字符串分割函数，支持两个分隔符
    
    Args:
        separator: 起始分隔符字符串
        text: 原始文本数据
        end_separator: 结束分隔符字符串，默认为空字符串
    
    Returns:
        分割后的内容列表，如果分隔符不存在则返回空列表
    """
    # 检查参数有效性
    if not separator or not text:
        return []
    
    # 处理转义字符（如\n）
    separator = separator.encode().decode('unicode_escape')
    end_separator = end_separator.encode().decode('unicode_escape') if end_separator else ""
    
    # 检查起始分隔符是否在文本中
    if separator not in text:
        return []
    
    # 如果没有结束分隔符，只使用起始分隔符进行分割
    if not end_separator:
        # 使用正则表达式分割文本
        parts = re.split(re.escape(separator), text)
        return parts
    
    # 检查结束分隔符是否在文本中
    if end_separator not in text:
        return []
    
    # 提取两个分隔符之间的内容
    pattern = f"{re.escape(separator)}(.*?){re.escape(end_separator)}"
    matches = re.findall(pattern, text, re.DOTALL)
    
    return matches

def create_list(name: str, elements: List[Any]) -> str:
    """
    创建新列表并添加到注册表
    
    Args:
        name: 列表的注册名
        elements: 列表中的元素
    
    Returns:
        新列表的ID
    """
    global registry
    
    # 生成列表ID
    list_id = generate_list_id()
    
    # 创建列表，第一个元素是注册名
    new_list = [name]
    new_list.extend(elements)
    
    # 添加到注册表
    registry[list_id] = new_list
    
    return list_id

def add_element(list_id: str, element: Any) -> str:
    """
    向指定列表添加元素
    
    Args:
        list_id: 列表ID
        element: 要添加的元素
    
    Returns:
        新元素的ID（如果是函数，则返回函数ID）
    """
    global registry
    
    if list_id not in registry:
        raise ValueError(f"列表 {list_id} 不存在")
    
    # 生成元素ID
    element_id = generate_element_id(list_id)
    
    # 如果元素是函数，创建函数ID（以5050结尾）
    if callable(element):
        func_id = element_id[:-4] + "5050"
        # 将函数添加到注册表（以函数ID为键）
        registry[func_id] = element
        # 在列表中添加函数ID引用
        registry[list_id].append(func_id)
        return func_id
    else:
        # 添加普通元素
        registry[list_id].append(element)
        return element_id

def find_element(list_id: str, element_name: str) -> Optional[str]:
    """
    在指定列表中查找元素
    
    Args:
        list_id: 列表ID
        element_name: 元素名称
    
    Returns:
        元素的ID，如果找不到则返回None
    """
    global registry
    
    if list_id not in registry:
        return None
    
    target_list = registry[list_id]
    
    # 查找元素
    for i, element in enumerate(target_list):
        if i == 0:  # 跳过第一个元素（列表名）
            continue
        if element == element_name:
            # 生成元素ID
            prefix = list_id.split('-')[0]
            return f"{prefix}-{i:04d}"
    
    return None

def execute_command(command_path: List[str]) -> Any:
    """
    执行命令
    
    Args:
        command_path: 命令路径，如 ["root", "math", "add"]
    
    Returns:
        命令执行结果，如果命令不存在则返回None
    """
    global registry
    
    current_list_id = "000-0000"  # 从根列表开始
    result = None
    
    for i, cmd in enumerate(command_path):
        if current_list_id not in registry:
            return None
        
        current_list = registry[current_list_id]
        
        # 如果是第一个命令，应该是列表名
        if i == 0:
            if current_list[0] != cmd:
                return None
            continue
        
        # 查找命令在当前列表中的位置
        found = False
        for j, element in enumerate(current_list):
            if j == 0:  # 跳过列表名
                continue
            
            if element == cmd:
                # 如果是最后一个命令，尝试执行
                if i == len(command_path) - 1:
                    # 检查是否是函数ID（以5050结尾）
                    if isinstance(element, str) and element.endswith("5050"):
                        func = registry.get(element)
                        if callable(func):
                            result = func()
                            return result
                    # 如果不是函数，返回元素本身
                    return element
                else:
                    # 查找下一级列表
                    element_id = find_element(current_list_id, cmd)
                    if element_id:
                        # 假设下一级列表的ID与元素ID相同（但以0000结尾）
                        next_list_id = element_id[:-4] + "0000"
                        if next_list_id in registry:
                            current_list_id = next_list_id
                            found = True
                            break
        
        if not found:
            return None
    
    return result

# 示例函数，用于演示
def pyt_function():
    """示例函数"""
    return "pyt函数执行结果"

def math_function():
    """示例函数"""
    return "math函数执行结果"

def data_function():
    """示例函数"""
    return "data函数执行结果"

# 测试函数
def test_system():
    """测试整个系统"""
    print("=" * 50)
    print("测试新的注册表系统")
    print("=" * 50)
    
    # 创建根列表
    root_id = create_list("root", ["pyt", "math", "data"])
    print(f"创建根列表: {registry[root_id]}")
    
    # 创建pyt子列表
    pyt_id = create_list("pyt", ["data", "process", "analyze"])
    print(f"创建pyt列表: {registry[pyt_id]}")
    
    # 向pyt列表添加函数
    func_id = add_element(pyt_id, data_function)
    print(f"向pyt列表添加函数: {registry[pyt_id]}")
    print(f"函数ID: {func_id}")
    
    # 测试命令执行
    print("\n测试命令执行:")
    
    # 执行命令: root -> pyt -> data_function
    result = execute_command(["root", "pyt", data_function.__name__])
    print(f"执行结果: {result}")
    
    # 查看注册表内容
    print("\n注册表内容:")
    for list_id, content in registry.items():
        print(f"{list_id}: {content}")

# 使用示例
if __name__ == "__main__":
    test_system()
